package DRCOMM;
import java.util.*;
import java.util.regex.*;

public class dr_html_template{

    public static void main(String[] args){
        String filename="./templates/echart.html";
        String content=dr_html_template.read_html_template(filename);
        System.out.println(content);
    }

    /**
     * 读取html文件，解析模板内容
     * @param filename:html文件
     * @return 返回解析后的html
     */
    public static String read_html_template(String filename){
        String content="";
        // 检查是否存在模板解析的内容
        if(child_template.check_html_template(filename)){
            // 如果存在模板，则将本文件设置为子模板
            child_template ct=new child_template();
            // 读取模板并转换为解析后的html
            ct.read_child_template(filename);
            content=ct.bt.content;
        }else{
            // 否则为普通html文件，但需要去除其中的 {{}} 段内容
            content=file_reader.read_file2string(filename);
            // 创建模式字符串
            String pattern = "\\{.*\\}";
            // 创建 Pattern 对象
            Pattern r = Pattern.compile(pattern);
            // 创建 matcher 对象
            Matcher m = r.matcher(content);
            while(m.find()){
                content=content.replace(m.group(0), "");
            }
            // System.out.println("静态文件！");
            // System.out.println(content);
        }
        return content;
    }

}

class base_template{

    String filename="";
    String content="";

    public base_template(String filename){
        this.read_base_template(filename);
    }

    /**
     * 读取模板文件
     * @param filename:模板文件
     * @return 该文件是否为模板文件，如果读取成功则会将content设置为模板文件转换后的html
     */
    public boolean read_base_template(String filename){
        // File f=new File(filename);
        try {
            this.filename=filename;
            List<String> contents=file_reader.read_file(filename);
            String macro="";
            // 创建模式字符串
            // String pattern = "\\{\\{\\s*url_for\\(\\'(.*)\\'\\s*,\\s*filename\\s*=\\s*\\'(.*)\\'\\s*\\)\\s*\\}\\}";
            String pattern = "\\{\\{.*\\}\\}";
            // 创建 Pattern 对象
            Pattern r = Pattern.compile(pattern);
            for(String content:contents){
                Matcher m = r.matcher(content);
                if(m.find()){
                    macro=m.group(0);
                    this.content+=content.replace(macro,this.convert_macro(m.group(0)))+"\n";
                }else{
                    this.content+=content+"\n";
                }
            }
            // 创建 matcher 对象
            return true;
        } catch (Exception e) {
            return false;
        }
        // if(f.exists()){
        // }else{
        //     return false;
        // }
    }

    /**
     * 转换宏指令为html
     * @param macro:宏指令，目前仅支持{{ url_for('目录', filename='资源') }}
     * @return 转换为html的字符串
     */
    private String convert_macro(String macro){
        String result="";
        // 创建模式字符串
        String pattern = "\\{\\{\\s*url_for\\(\\'(.*)\\'\\s*,\\s*filename\\s*=\\s*\\'(.*)\\'\\s*\\)\\s*\\}\\}";
        // 创建 Pattern 对象
        Pattern r = Pattern.compile(pattern);
        // 创建 matcher 对象
        Matcher m = r.matcher(macro);
        if(m.find()){
            // result+=m.group(1);
            String path=m.group(1);
            String file=m.group(2);
            result=String.format("/%s/%s",path,file);
            // System.out.println(result);
        }
        return result;
    }
}

class child_template{

    String filename="";
    String content="";
    // block块对象
    HashMap<String,String> blocks=new HashMap<>();
    // 模板文件对象
    base_template bt=null;

    /**
     * 读取子模板文件（其中使用了模板）
     * @param filename:文件名
     * @return 读取成功后返回真值，同时该对象的content内容为解析后的html，否则返回假值
     */
    public boolean read_child_template(String filename){
        // File f=new File(filename);
        // 判断文件是否存在
        try {
            this.filename=filename;
            // 读取全部内容
            String contents=file_reader.read_file2string(filename);
            // 读取模板名称
            // 创建模式字符串
            String pattern = "\\{%\\s*extends\\s*\"(.*)\"\\s*%\\}";
            // 创建 Pattern 对象
            Pattern r = Pattern.compile(pattern);
            // 创建 matcher 对象
            Matcher m = r.matcher(contents);
            // template_block tb;
            // 如果能找到模板则继续处理
            if(m.find()){

                // 找到子模板的block部分
                // 创建模式字符串
                String sub_pattern;
                sub_pattern = "\\{%\\s*block\\s*(\\w*)\\s*%\\}(.*?)\\{%\\s*endblock\\s*%\\}";
                // 创建 Pattern 对象
                Pattern sub_r;
                sub_r=Pattern.compile(sub_pattern,Pattern.DOTALL);
                // 创建 matcher 对象
                Matcher sub_m;
                sub_m=sub_r.matcher(contents);
                // 逐个添加到blocks中
                while(sub_m.find()){
                    // System.out.println(sub_m.group(1));
                    // System.out.println(sub_m.group(2));
                    this.blocks.put(sub_m.group(1), sub_m.group(2));
                }

                // 找到模板文件并读取
                this.bt=new base_template("./templates/"+m.group(1));
                // 找到模板的block部分
                // 创建模式字符串
                String block_pattern;
                // {% block content %}
                // {% endblock %}
                block_pattern = "\\{%\\s*block\\s*(\\w*)\\s*%\\}(.*?)\\{%\\s*endblock\\s*%\\}";
                // 创建 Pattern 对象
                Pattern block_r;
                block_r=Pattern.compile(block_pattern,Pattern.DOTALL);
                // 创建 matcher 对象
                Matcher block_m;
                block_m=block_r.matcher(bt.content);

                // 根据模板中的block段，替换子模板中的对应block段
                while(block_m.find()){
                    // System.out.println(block_m.group(1));
                    if(this.blocks.containsKey(block_m.group(1)))
                        bt.content=bt.content.replace(block_m.group(0), this.blocks.get(block_m.group(1)));
                    else
                        bt.content=bt.content.replace(block_m.group(0), "");
                }
                return true;
            }else{
                return false;
            }
        }catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断文件是否存在需要解析的模板内容
     * @param filename:html文件名
     * @return 如果存在{% extends %} 段，说明需要解析，返回真值，否则返回假值
     */
    public static boolean check_html_template(String filename){
        try {
            String contents=file_reader.read_file2string(filename);
            // 创建模式字符串
            String pattern = "\\{%\\s*extends\\s*\"(.*)\"\\s*%\\}";
            // 创建 Pattern 对象
            Pattern r = Pattern.compile(pattern);
            // 创建 matcher 对象
            Matcher m = r.matcher(contents);
            // template_block tb;
            if(m.find()){    
                return true;
            }else{
                return false;
            }
        } catch (Exception e) {
        }
        return false;
    }
    
}
